<?php

//
// $Id: sphinxclient.class.php 2055 2009-11-06 23:09:58Z shodan $
//

//
// Copyright (c) 2001-2008, Andrew Aksyonoff. All rights reserved.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License. You should have
// received a copy of the GPL license along with this program; if you
// did not, you can find it at http://www.gnu.org/
//

/////////////////////////////////////////////////////////////////////////////
// PHP version of Sphinx searchd client (PHP API)
/////////////////////////////////////////////////////////////////////////////

/// known searchd commands
define("SEARCHD_COMMAND_SEARCH",    0);
define("SEARCHD_COMMAND_EXCERPT",    1);
define("SEARCHD_COMMAND_UPDATE",    2);
define("SEARCHD_COMMAND_KEYWORDS", 3);
define("SEARCHD_COMMAND_PERSIST",    4);
define("SEARCHD_COMMAND_STATUS",    5);
define("SEARCHD_COMMAND_QUERY",    6);

/// current client-side command implementation versions
define("VER_COMMAND_SEARCH",        0x116);
define("VER_COMMAND_EXCERPT",        0x100);
define("VER_COMMAND_UPDATE",        0x102);
define("VER_COMMAND_KEYWORDS",    0x100);
define("VER_COMMAND_STATUS",        0x100);
define("VER_COMMAND_QUERY",        0x100);

/// known searchd status codes
define("SEARCHD_OK",                0);
define("SEARCHD_ERROR",            1);
define("SEARCHD_RETRY",            2);
define("SEARCHD_WARNING",            3);

/// known match modes
define("SPH_MATCH_ALL",            0);
define("SPH_MATCH_ANY",            1);
define("SPH_MATCH_PHRASE",        2);
define("SPH_MATCH_BOOLEAN",        3);
define("SPH_MATCH_EXTENDED",        4);
define("SPH_MATCH_FULLSCAN",        5);
define("SPH_MATCH_EXTENDED2",        6);    // extended engine V2 (TEMPORARY, WILL BE REMOVED)

/// known ranking modes (ext2 only)
define("SPH_RANK_PROXIMITY_BM25",    0);    ///< default mode, phrase proximity major factor and BM25 minor one
define("SPH_RANK_BM25",            1);    ///< statistical mode, BM25 ranking only (faster but worse quality)
define("SPH_RANK_NONE",            2);    ///< no ranking, all matches get a weight of 1
define("SPH_RANK_WORDCOUNT",        3);    ///< simple word-count weighting, rank is a weighted sum of per-field keyword occurence counts
define("SPH_RANK_PROXIMITY",        4);
define("SPH_RANK_MATCHANY",        5);
define("SPH_RANK_FIELDMASK",        6);

/// known sort modes
define("SPH_SORT_RELEVANCE",        0);
define("SPH_SORT_ATTR_DESC",        1);
define("SPH_SORT_ATTR_ASC",        2);
define("SPH_SORT_TIME_SEGMENTS",     3);
define("SPH_SORT_EXTENDED",         4);
define("SPH_SORT_EXPR",             5);

/// known filter types
define("SPH_FILTER_VALUES",        0);
define("SPH_FILTER_RANGE",        1);
define("SPH_FILTER_FLOATRANGE",    2);

/// known attribute types
define("SPH_ATTR_INTEGER",        1);
define("SPH_ATTR_TIMESTAMP",        2);
define("SPH_ATTR_ORDINAL",        3);
define("SPH_ATTR_BOOL",            4);
define("SPH_ATTR_FLOAT",            5);
define("SPH_ATTR_BIGINT",            6);
define("SPH_ATTR_MULTI",            0x40000000);

/// known grouping functions
define("SPH_GROUPBY_DAY",            0);
define("SPH_GROUPBY_WEEK",        1);
define("SPH_GROUPBY_MONTH",        2);
define("SPH_GROUPBY_YEAR",        3);
define("SPH_GROUPBY_ATTR",        4);
define("SPH_GROUPBY_ATTRPAIR",    5);

// important properties of PHP's integers:
//  - always signed (one bit short of PHP_INT_SIZE)
//  - conversion from string to int is saturated
//  - float is double
//  - div converts arguments to floats
//  - mod converts arguments to ints

// the packing code below works as follows:
//  - when we got an int, just pack it
//    if performance is a problem, this is the branch users should aim for
//
//  - otherwise, we got a number in string form
//    this might be due to different reasons, but we assume that this is
//    because it didn't fit into PHP int
//
//  - factor the string into high and low ints for packing
//    - if we have bcmath, then it is used
//    - if we don't, we have to do it manually (this is the fun part)
//
//    - x64 branch does factoring using ints
//    - x32 (ab)uses floats, since we can't fit unsigned 32-bit number into an int
//
// unpacking routines are pretty much the same.
//  - return ints if we can
//  - otherwise format number into a string

/// pack 64-bit signed
function sphPackI64( $v )
{
    assert(is_numeric($v));
    
    // x64
    if (PHP_INT_SIZE>=8 ) {
        $v = (int)$v;
        return pack("NN", $v>>32, $v&0xFFFFFFFF);
    }

    // x32, int
    if (is_int($v) ) {
        return pack("NN", $v < 0 ? -1 : 0, $v);
    }

    // x32, bcmath    
    if (function_exists("bcmul") ) {
        if (bccomp($v, 0) == -1 ) {
            $v = bcadd("18446744073709551616", $v);
        }
        $h = bcdiv($v, "4294967296", 0);
        $l = bcmod($v, "4294967296");
        return pack("NN", (float)$h, (float)$l); // conversion to float is intentional; int would lose 31st bit
    }

    // x32, no-bcmath
    $p = max(0, strlen($v) - 13);
    $lo = abs((float)substr($v, $p));
    $hi = abs((float)substr($v, 0, $p));

    $m = $lo + $hi*1316134912.0; // (10 ^ 13) % (1 << 32) = 1316134912
    $q = floor($m/4294967296.0);
    $l = $m - ($q*4294967296.0);
    $h = $hi*2328.0 + $q; // (10 ^ 13) / (1 << 32) = 2328

    if ($v<0 ) {
        if ($l==0 ) {
            $h = 4294967296.0 - $h;
        } else
        {
            $h = 4294967295.0 - $h;
            $l = 4294967296.0 - $l;
        }
    }
    return pack("NN", $h, $l);
}

/// pack 64-bit unsigned
function sphPackU64( $v )
{
    assert(is_numeric($v));
    
    // x64
    if (PHP_INT_SIZE>=8 ) {
        assert($v>=0);
        
        // x64, int
        if (is_int($v) ) {
            return pack("NN", $v>>32, $v&0xFFFFFFFF);
        }
                          
        // x64, bcmath
        if (function_exists("bcmul") ) {
            $h = bcdiv($v, 4294967296, 0);
            $l = bcmod($v, 4294967296);
            return pack("NN", $h, $l);
        }
        
        // x64, no-bcmath
        $p = max(0, strlen($v) - 13);
        $lo = (int)substr($v, $p);
        $hi = (int)substr($v, 0, $p);
    
        $m = $lo + $hi*1316134912;
        $l = $m % 4294967296;
        $h = $hi*2328 + (int)($m/4294967296);

        return pack("NN", $h, $l);
    }

    // x32, int
    if (is_int($v) ) {
        return pack("NN", 0, $v);
    }
    
    // x32, bcmath
    if (function_exists("bcmul") ) {
        $h = bcdiv($v, "4294967296", 0);
        $l = bcmod($v, "4294967296");
        return pack("NN", (float)$h, (float)$l); // conversion to float is intentional; int would lose 31st bit
    }

    // x32, no-bcmath
    $p = max(0, strlen($v) - 13);
    $lo = (float)substr($v, $p);
    $hi = (float)substr($v, 0, $p);
    
    $m = $lo + $hi*1316134912.0;
    $q = floor($m / 4294967296.0);
    $l = $m - ($q * 4294967296.0);
    $h = $hi*2328.0 + $q;

    return pack("NN", $h, $l);
}

// unpack 64-bit unsigned
function sphUnpackU64( $v )
{
    list ( $hi, $lo ) = array_values(unpack("N*N*", $v));

    if (PHP_INT_SIZE>=8 ) {
        if ($hi<0 ) { $hi += (1<<32); // because php 5.2.2 to 5.2.5 is totally fucked up again
        }
        if ($lo<0 ) { $lo += (1<<32);
        }

        // x64, int
        if ($hi<=2147483647 ) {
            return ($hi<<32) + $lo;
        }

        // x64, bcmath
        if (function_exists("bcmul") ) {
            return bcadd($lo, bcmul($hi, "4294967296"));
        }

        // x64, no-bcmath
        $C = 100000;
        $h = ((int)($hi / $C) << 32) + (int)($lo / $C);
        $l = (($hi % $C) << 32) + ($lo % $C);
        if ($l>$C ) {
            $h += (int)($l / $C);
            $l  = $l % $C;
        }

        if ($h==0 ) {
            return $l;
        }
        return sprintf("%d%05d", $h, $l);
    }

    // x32, int
    if ($hi==0 ) {
        if ($lo>0 ) {
            return $lo;
        }
        return sprintf("%u", $lo);
    }

    $hi = sprintf("%u", $hi);
    $lo = sprintf("%u", $lo);

    // x32, bcmath
    if (function_exists("bcmul") ) {
        return bcadd($lo, bcmul($hi, "4294967296"));
    }
    
    // x32, no-bcmath
    $hi = (float)$hi;
    $lo = (float)$lo;
    
    $q = floor($hi/10000000.0);
    $r = $hi - $q*10000000.0;
    $m = $lo + $r*4967296.0;
    $mq = floor($m/10000000.0);
    $l = $m - $mq*10000000.0;
    $h = $q*4294967296.0 + $r*429.0 + $mq;

    $h = sprintf("%.0f", $h);
    $l = sprintf("%07.0f", $l);
    if ($h=="0" ) {
        return sprintf("%.0f", (float)$l);
    }
    return $h . $l;
}

// unpack 64-bit signed
function sphUnpackI64( $v )
{
    list ( $hi, $lo ) = array_values(unpack("N*N*", $v));

    // x64
    if (PHP_INT_SIZE>=8 ) {
        if ($hi<0 ) { $hi += (1<<32); // because php 5.2.2 to 5.2.5 is totally fucked up again
        }
        if ($lo<0 ) { $lo += (1<<32);
        }

        return ($hi<<32) + $lo;
    }

    // x32, int
    if ($hi==0 ) {
        if ($lo>0 ) {
            return $lo;
        }
        return sprintf("%u", $lo);
    }
    // x32, int
    elseif ($hi==-1 ) {
        if ($lo<0 ) {
            return $lo;
        }
        return sprintf("%.0f", $lo - 4294967296.0);
    }
    
    $neg = "";
    $c = 0;
    if ($hi<0 ) {
        $hi = ~$hi;
        $lo = ~$lo;
        $c = 1;
        $neg = "-";
    }    

    $hi = sprintf("%u", $hi);
    $lo = sprintf("%u", $lo);

    // x32, bcmath
    if (function_exists("bcmul") ) {
        return $neg . bcadd(bcadd($lo, bcmul($hi, "4294967296")), $c);
    }

    // x32, no-bcmath
    $hi = (float)$hi;
    $lo = (float)$lo;
    
    $q = floor($hi/10000000.0);
    $r = $hi - $q*10000000.0;
    $m = $lo + $r*4967296.0;
    $mq = floor($m/10000000.0);
    $l = $m - $mq*10000000.0 + $c;
    $h = $q*4294967296.0 + $r*429.0 + $mq;
    if ($l==10000000 ) {
        $l = 0;
        $h += 1;
    }

    $h = sprintf("%.0f", $h);
    $l = sprintf("%07.0f", $l);
    if ($h=="0" ) {
        return $neg . sprintf("%.0f", (float)$l);
    }
    return $neg . $h . $l;
}


function sphFixUint( $value )
{
    if (PHP_INT_SIZE>=8 ) {
        // x64 route, workaround broken unpack() in 5.2.2+
        if ($value<0 ) { $value += (1<<32);
        }
        return $value;
    }
    else
    {
        // x32 route, workaround php signed/unsigned braindamage
        return sprintf("%u", $value);
    }
}


/// sphinx searchd client class
class SphinxClient
{
    var $_host;            ///< searchd host (default is "localhost")
    var $_port;            ///< searchd port (default is 9312)
    var $_offset;        ///< how many records to seek from result-set start (default is 0)
    var $_limit;        ///< how many records to return from result-set starting at offset (default is 20)
    var $_mode;            ///< query matching mode (default is SPH_MATCH_ALL)
    var $_weights;        ///< per-field weights (default is 1 for all fields)
    var $_sort;            ///< match sorting mode (default is SPH_SORT_RELEVANCE)
    var $_sortby;        ///< attribute to sort by (defualt is "")
    var $_min_id;        ///< min ID to match (default is 0, which means no limit)
    var $_max_id;        ///< max ID to match (default is 0, which means no limit)
    var $_filters;        ///< search filters
    var $_groupby;        ///< group-by attribute name
    var $_groupfunc;    ///< group-by function (to pre-process group-by attribute value with)
    var $_groupsort;    ///< group-by sorting clause (to sort groups in result set with)
    var $_groupdistinct;///< group-by count-distinct attribute
    var $_maxmatches;    ///< max matches to retrieve
    var $_cutoff;        ///< cutoff to stop searching at (default is 0)
    var $_retrycount;    ///< distributed retries count
    var $_retrydelay;    ///< distributed retries delay
    var $_anchor;        ///< geographical anchor point
    var $_indexweights;    ///< per-index weights
    var $_ranker;        ///< ranking mode (default is SPH_RANK_PROXIMITY_BM25)
    var $_maxquerytime;    ///< max query time, milliseconds (default is 0, do not limit)
    var $_fieldweights;    ///< per-field-name weights
    var $_overrides;    ///< per-query attribute values overrides
    var $_select;        ///< select-list (attributes or expressions, with optional aliases)

    var $_error;        ///< last error message
    var $_warning;        ///< last warning message
    var $_connerror;        ///< connection error vs remote error flag

    var $_reqs;            ///< requests array for multi-query
    var $_mbenc;        ///< stored mbstring encoding
    var $_arrayresult;    ///< whether $result["matches"] should be a hash or an array
    var $_timeout;        ///< connect timeout

    /////////////////////////////////////////////////////////////////////////////
    // common stuff
    /////////////////////////////////////////////////////////////////////////////

    /// create a new client object and fill defaults
    function SphinxClient()
    {
        // per-client-object settings
        $this->_host        = "localhost";
        $this->_port        = 9312;
        $this->_path        = false;
        $this->_socket        = false;

        // per-query settings
        $this->_offset        = 0;
        $this->_limit        = 20;
        $this->_mode        = SPH_MATCH_ALL;
        $this->_weights        = array ();
        $this->_sort        = SPH_SORT_RELEVANCE;
        $this->_sortby        = "";
        $this->_min_id        = 0;
        $this->_max_id        = 0;
        $this->_filters        = array ();
        $this->_groupby        = "";
        $this->_groupfunc    = SPH_GROUPBY_DAY;
        $this->_groupsort    = "@group desc";
        $this->_groupdistinct= "";
        $this->_maxmatches    = 1000;
        $this->_cutoff        = 0;
        $this->_retrycount    = 0;
        $this->_retrydelay    = 0;
        $this->_anchor        = array ();
        $this->_indexweights= array ();
        $this->_ranker        = SPH_RANK_PROXIMITY_BM25;
        $this->_maxquerytime= 0;
        $this->_fieldweights= array();
        $this->_overrides     = array();
        $this->_select        = "*";

        $this->_error        = ""; // per-reply fields (for single-query case)
        $this->_warning        = "";
        $this->_connerror    = false;

        $this->_reqs        = array ();    // requests storage (for multi-query case)
        $this->_mbenc        = "";
        $this->_arrayresult    = false;
        $this->_timeout        = 0;
    }

    function __destruct()
    {
        if ($this->_socket !== false ) {
            fclose($this->_socket);
        }
    }

    /// get last error message (string)
    function GetLastError()
    {
        return $this->_error;
    }

    /// get last warning message (string)
    function GetLastWarning()
    {
        return $this->_warning;
    }

    /// get last error flag (to tell network connection errors from searchd errors or broken responses)
    function IsConnectError()
    {
        return $this->_connerror;
    }

    /// set searchd host name (string) and port (integer)
    function SetServer( $host, $port = 0 )
    {
        assert(is_string($host));
        if ($host[0] == '/') {
            $this->_path = 'unix://' . $host;
            return;
        }
        if (substr($host, 0, 7)=="unix://" ) {
            $this->_path = $host;
            return;
        }
                
        assert(is_int($port));
        $this->_host = $host;
        $this->_port = $port;
        $this->_path = '';

    }

    /// set server connection timeout (0 to remove)
    function SetConnectTimeout( $timeout )
    {
        assert(is_numeric($timeout));
        $this->_timeout = $timeout;
    }


    function _Send( $handle, $data, $length )
    {
        if (feof($handle) || fwrite($handle, $data, $length) !== $length ) {
            $this->_error = 'connection unexpectedly closed (timed out?)';
            $this->_connerror = true;
            return false;
        }
        return true;
    }

    /////////////////////////////////////////////////////////////////////////////

    /// enter mbstring workaround mode
    function _MBPush()
    {
        $this->_mbenc = "";
        if (ini_get("mbstring.func_overload") & 2 ) {
            $this->_mbenc = mb_internal_encoding();
            mb_internal_encoding("latin1");
        }
    }

    /// leave mbstring workaround mode
    function _MBPop()
    {
        if ($this->_mbenc ) {
            mb_internal_encoding($this->_mbenc);
        }
    }

    /// connect to searchd server
    function _Connect()
    {
        if ($this->_socket!==false ) {
            // we are in persistent connection mode, so we have a socket
            // however, need to check whether it's still alive
            if (!@feof($this->_socket) ) {
                return $this->_socket;
            }

            // force reopen
            $this->_socket = false;
        }

        $errno = 0;
        $errstr = "";
        $this->_connerror = false;

        if ($this->_path ) {
            $host = $this->_path;
            $port = 0;
        }
        else
        {
            $host = $this->_host;
            $port = $this->_port;
        }

        if ($this->_timeout<=0 ) {
            $fp = @fsockopen($host, $port, $errno, $errstr);
        } else {
            $fp = @fsockopen($host, $port, $errno, $errstr, $this->_timeout);
        }
        
        if (!$fp ) {
            if ($this->_path ) {
                $location = $this->_path;
            } else {
                $location = "{$this->_host}:{$this->_port}";
            }
            
            $errstr = trim($errstr);
            $this->_error = "connection to $location failed (errno=$errno, msg=$errstr)";
            $this->_connerror = true;
            return false;
        }

        // send my version
        // this is a subtle part. we must do it before (!) reading back from searchd.
        // because otherwise under some conditions (reported on FreeBSD for instance)
        // TCP stack could throttle write-write-read pattern because of Nagle.
        if (!$this->_Send($fp, pack("N", 1), 4) ) {
            fclose($fp);
            $this->_error = "failed to send client protocol version";
            return false;
        }

        // check version
        list(,$v) = unpack("N*", fread($fp, 4));
        $v = (int)$v;
        if ($v<1 ) {
            fclose($fp);
            $this->_error = "expected searchd protocol version 1+, got version '$v'";
            return false;
        }

        return $fp;
    }

    /// get and check response packet from searchd server
    function _GetResponse( $fp, $client_ver )
    {
        $response = "";
        $len = 0;

        $header = fread($fp, 8);
        if (strlen($header)==8 ) {
            list ( $status, $ver, $len ) = array_values(unpack("n2a/Nb", $header));
            $left = $len;
            while ( $left>0 && !feof($fp) )
            {
                $chunk = fread($fp, $left);
                if ($chunk ) {
                    $response .= $chunk;
                    $left -= strlen($chunk);
                }
            }
        }
        if ($this->_socket === false ) {
            fclose($fp);
        }

        // check response
        $read = strlen($response);
        if (!$response || $read!=$len ) {
            $this->_error = $len
            ? "failed to read searchd response (status=$status, ver=$ver, len=$len, read=$read)"
            : "received zero-sized searchd response";
            return false;
        }

        // check status
        if ($status==SEARCHD_WARNING ) {
            list(,$wlen) = unpack("N*", substr($response, 0, 4));
            $this->_warning = substr($response, 4, $wlen);
            return substr($response, 4+$wlen);
        }
        if ($status==SEARCHD_ERROR ) {
            $this->_error = "searchd error: " . substr($response, 4);
            return false;
        }
        if ($status==SEARCHD_RETRY ) {
            $this->_error = "temporary searchd error: " . substr($response, 4);
            return false;
        }
        if ($status!=SEARCHD_OK ) {
            $this->_error = "unknown status code '$status'";
            return false;
        }

        // check version
        if ($ver<$client_ver ) {
            $this->_warning = sprintf(
                "searchd command v.%d.%d older than client's v.%d.%d, some options might not work",
                $ver>>8, $ver&0xff, $client_ver>>8, $client_ver&0xff 
            );
        }

        return $response;
    }

    /////////////////////////////////////////////////////////////////////////////
    // searching
    /////////////////////////////////////////////////////////////////////////////

    /// set offset and count into result set,
    /// and optionally set max-matches and cutoff limits
    function SetLimits( $offset, $limit, $max=0, $cutoff=0 )
    {
        assert(is_int($offset));
        assert(is_int($limit));
        assert($offset>=0);
        assert($limit>0);
        assert($max>=0);
        $this->_offset = $offset;
        $this->_limit = $limit;
        if ($max>0 ) {
            $this->_maxmatches = $max;
        }
        if ($cutoff>0 ) {
            $this->_cutoff = $cutoff;
        }
    }

    /// set maximum query time, in milliseconds, per-index
    /// integer, 0 means "do not limit"
    function SetMaxQueryTime( $max )
    {
        assert(is_int($max));
        assert($max>=0);
        $this->_maxquerytime = $max;
    }

    /// set matching mode
    function SetMatchMode( $mode )
    {
        assert(
            $mode==SPH_MATCH_ALL
            || $mode==SPH_MATCH_ANY
            || $mode==SPH_MATCH_PHRASE
            || $mode==SPH_MATCH_BOOLEAN
            || $mode==SPH_MATCH_EXTENDED
            || $mode==SPH_MATCH_FULLSCAN
            || $mode==SPH_MATCH_EXTENDED2 
        );
        $this->_mode = $mode;
    }

    /// set ranking mode
    function SetRankingMode( $ranker )
    {
        assert(
            $ranker==SPH_RANK_PROXIMITY_BM25
            || $ranker==SPH_RANK_BM25
            || $ranker==SPH_RANK_NONE
            || $ranker==SPH_RANK_WORDCOUNT
            || $ranker==SPH_RANK_PROXIMITY 
        );
        $this->_ranker = $ranker;
    }

    /// set matches sorting mode
    function SetSortMode( $mode, $sortby="" )
    {
        assert(
            $mode==SPH_SORT_RELEVANCE ||
            $mode==SPH_SORT_ATTR_DESC ||
            $mode==SPH_SORT_ATTR_ASC ||
            $mode==SPH_SORT_TIME_SEGMENTS ||
            $mode==SPH_SORT_EXTENDED ||
            $mode==SPH_SORT_EXPR 
        );
        assert(is_string($sortby));
        assert($mode==SPH_SORT_RELEVANCE || strlen($sortby)>0);

        $this->_sort = $mode;
        $this->_sortby = $sortby;
    }

    /// bind per-field weights by order
    /// DEPRECATED; use SetFieldWeights() instead
    function SetWeights( $weights )
    {
        assert(is_array($weights));
        foreach ( $weights as $weight ) {
            assert(is_int($weight));
        }

        $this->_weights = $weights;
    }

    /// bind per-field weights by name
    function SetFieldWeights( $weights )
    {
        assert(is_array($weights));
        foreach ( $weights as $name=>$weight )
        {
            assert(is_string($name));
            assert(is_int($weight));
        }
        $this->_fieldweights = $weights;
    }

    /// bind per-index weights by name
    function SetIndexWeights( $weights )
    {
        assert(is_array($weights));
        foreach ( $weights as $index=>$weight )
        {
            assert(is_string($index));
            assert(is_int($weight));
        }
        $this->_indexweights = $weights;
    }

    /// set IDs range to match
    /// only match records if document ID is beetwen $min and $max (inclusive)
    function SetIDRange( $min, $max )
    {
        assert(is_numeric($min));
        assert(is_numeric($max));
        assert($min<=$max);
        $this->_min_id = $min;
        $this->_max_id = $max;
    }

    /// set values set filter
    /// only match records where $attribute value is in given set
    function SetFilter( $attribute, $values, $exclude=false )
    {
        assert(is_string($attribute));
        assert(is_array($values));
        assert(count($values));

        if (is_array($values) && count($values) ) {
            foreach ( $values as $value ) {
                assert(is_numeric($value));
            }

            $this->_filters[] = array ( "type"=>SPH_FILTER_VALUES, "attr"=>$attribute, "exclude"=>$exclude, "values"=>$values );
        }
    }

    /// set range filter
    /// only match records if $attribute value is beetwen $min and $max (inclusive)
    function SetFilterRange( $attribute, $min, $max, $exclude=false )
    {
        assert(is_string($attribute));
        assert(is_numeric($min));
        assert(is_numeric($max));
        assert($min<=$max);

        $this->_filters[] = array ( "type"=>SPH_FILTER_RANGE, "attr"=>$attribute, "exclude"=>$exclude, "min"=>$min, "max"=>$max );
    }

    /// set float range filter
    /// only match records if $attribute value is beetwen $min and $max (inclusive)
    function SetFilterFloatRange( $attribute, $min, $max, $exclude=false )
    {
        assert(is_string($attribute));
        assert(is_float($min));
        assert(is_float($max));
        assert($min<=$max);

        $this->_filters[] = array ( "type"=>SPH_FILTER_FLOATRANGE, "attr"=>$attribute, "exclude"=>$exclude, "min"=>$min, "max"=>$max );
    }

    /// setup anchor point for geosphere distance calculations
    /// required to use @geodist in filters and sorting
    /// latitude and longitude must be in radians
    function SetGeoAnchor( $attrlat, $attrlong, $lat, $long )
    {
        assert(is_string($attrlat));
        assert(is_string($attrlong));
        assert(is_float($lat));
        assert(is_float($long));

        $this->_anchor = array ( "attrlat"=>$attrlat, "attrlong"=>$attrlong, "lat"=>$lat, "long"=>$long );
    }

    /// set grouping attribute and function
    function SetGroupBy( $attribute, $func, $groupsort="@group desc" )
    {
        assert(is_string($attribute));
        assert(is_string($groupsort));
        assert(
            $func==SPH_GROUPBY_DAY
            || $func==SPH_GROUPBY_WEEK
            || $func==SPH_GROUPBY_MONTH
            || $func==SPH_GROUPBY_YEAR
            || $func==SPH_GROUPBY_ATTR
            || $func==SPH_GROUPBY_ATTRPAIR 
        );

        $this->_groupby = $attribute;
        $this->_groupfunc = $func;
        $this->_groupsort = $groupsort;
    }

    /// set count-distinct attribute for group-by queries
    function SetGroupDistinct( $attribute )
    {
        assert(is_string($attribute));
        $this->_groupdistinct = $attribute;
    }

    /// set distributed retries count and delay
    function SetRetries( $count, $delay=0 )
    {
        assert(is_int($count) && $count>=0);
        assert(is_int($delay) && $delay>=0);
        $this->_retrycount = $count;
        $this->_retrydelay = $delay;
    }

    /// set result set format (hash or array; hash by default)
    /// PHP specific; needed for group-by-MVA result sets that may contain duplicate IDs
    function SetArrayResult( $arrayresult )
    {
        assert(is_bool($arrayresult));
        $this->_arrayresult = $arrayresult;
    }

    /// set attribute values override
    /// there can be only one override per attribute
    /// $values must be a hash that maps document IDs to attribute values
    function SetOverride( $attrname, $attrtype, $values )
    {
        assert(is_string($attrname));
        assert(in_array($attrtype, array ( SPH_ATTR_INTEGER, SPH_ATTR_TIMESTAMP, SPH_ATTR_BOOL, SPH_ATTR_FLOAT, SPH_ATTR_BIGINT )));
        assert(is_array($values));

        $this->_overrides[$attrname] = array ( "attr"=>$attrname, "type"=>$attrtype, "values"=>$values );
    }

    /// set select-list (attributes or expressions), SQL-like syntax
    function SetSelect( $select )
    {
        assert(is_string($select));
        $this->_select = $select;
    }

    //////////////////////////////////////////////////////////////////////////////

    /// clear all filters (for multi-queries)
    function ResetFilters()
    {
        $this->_filters = array();
        $this->_anchor = array();
    }

    /// clear groupby settings (for multi-queries)
    function ResetGroupBy()
    {
        $this->_groupby        = "";
        $this->_groupfunc    = SPH_GROUPBY_DAY;
        $this->_groupsort    = "@group desc";
        $this->_groupdistinct= "";
    }

    /// clear all attribute value overrides (for multi-queries)
    function ResetOverrides()
    {
        $this->_overrides = array ();
    }

    //////////////////////////////////////////////////////////////////////////////

    /// connect to searchd server, run given search query through given indexes,
    /// and return the search results
    function Query( $query, $index="*", $comment="" )
    {
        assert(empty($this->_reqs));

        $this->AddQuery($query, $index, $comment);
        $results = $this->RunQueries();
        $this->_reqs = array (); // just in case it failed too early

        if (!is_array($results) ) {
            return false; // probably network error; error message should be already filled
        }

        $this->_error = $results[0]["error"];
        $this->_warning = $results[0]["warning"];
        if ($results[0]["status"]==SEARCHD_ERROR ) {
            return false;
        } else {
            return $results[0];
        }
    }

    /// helper to pack floats in network byte order
    function _PackFloat( $f )
    {
        $t1 = pack("f", $f); // machine order
        list(,$t2) = unpack("L*", $t1); // int in machine order
        return pack("N", $t2);
    }

    /// add query to multi-query batch
    /// returns index into results array from RunQueries() call
    function AddQuery( $query, $index="*", $comment="" )
    {
        // mbstring workaround
        $this->_MBPush();

        // build request
        $req = pack("NNNNN", $this->_offset, $this->_limit, $this->_mode, $this->_ranker, $this->_sort); // mode and limits
        $req .= pack("N", strlen($this->_sortby)) . $this->_sortby;
        $req .= pack("N", strlen($query)) . $query; // query itself
        $req .= pack("N", count($this->_weights)); // weights
        foreach ( $this->_weights as $weight ) {
            $req .= pack("N", (int)$weight);
        }
        $req .= pack("N", strlen($index)) . $index; // indexes
        $req .= pack("N", 1); // id64 range marker
        $req .= sphPackU64($this->_min_id) . sphPackU64($this->_max_id); // id64 range

        // filters
        $req .= pack("N", count($this->_filters));
        foreach ( $this->_filters as $filter )
        {
            $req .= pack("N", strlen($filter["attr"])) . $filter["attr"];
            $req .= pack("N", $filter["type"]);
            switch ( $filter["type"] )
            {
            case SPH_FILTER_VALUES:
                $req .= pack("N", count($filter["values"]));
                foreach ( $filter["values"] as $value ) {
                    $req .= sphPackI64($value);
                }
                break;

            case SPH_FILTER_RANGE:
                $req .= sphPackI64($filter["min"]) . sphPackI64($filter["max"]);
                break;

            case SPH_FILTER_FLOATRANGE:
                   $req .= $this->_PackFloat($filter["min"]) . $this->_PackFloat($filter["max"]);
                break;

            default:
                assert(0 && "internal error: unhandled filter type");
            }
            $req .= pack("N", $filter["exclude"]);
        }

        // group-by clause, max-matches count, group-sort clause, cutoff count
        $req .= pack("NN", $this->_groupfunc, strlen($this->_groupby)) . $this->_groupby;
        $req .= pack("N", $this->_maxmatches);
        $req .= pack("N", strlen($this->_groupsort)) . $this->_groupsort;
        $req .= pack("NNN", $this->_cutoff, $this->_retrycount, $this->_retrydelay);
        $req .= pack("N", strlen($this->_groupdistinct)) . $this->_groupdistinct;

        // anchor point
        if (empty($this->_anchor) ) {
            $req .= pack("N", 0);
        } else
        {
            $a =& $this->_anchor;
            $req .= pack("N", 1);
            $req .= pack("N", strlen($a["attrlat"])) . $a["attrlat"];
            $req .= pack("N", strlen($a["attrlong"])) . $a["attrlong"];
            $req .= $this->_PackFloat($a["lat"]) . $this->_PackFloat($a["long"]);
        }

        // per-index weights
        $req .= pack("N", count($this->_indexweights));
        foreach ( $this->_indexweights as $idx=>$weight ) {
            $req .= pack("N", strlen($idx)) . $idx . pack("N", $weight);
        }

        // max query time
        $req .= pack("N", $this->_maxquerytime);

        // per-field weights
        $req .= pack("N", count($this->_fieldweights));
        foreach ( $this->_fieldweights as $field=>$weight ) {
            $req .= pack("N", strlen($field)) . $field . pack("N", $weight);
        }

        // comment
        $req .= pack("N", strlen($comment)) . $comment;

        // attribute overrides
        $req .= pack("N", count($this->_overrides));
        foreach ( $this->_overrides as $key => $entry )
        {
            $req .= pack("N", strlen($entry["attr"])) . $entry["attr"];
            $req .= pack("NN", $entry["type"], count($entry["values"]));
            foreach ( $entry["values"] as $id=>$val )
            {
                assert(is_numeric($id));
                assert(is_numeric($val));

                $req .= sphPackU64($id);
                switch ( $entry["type"] )
                {
                case SPH_ATTR_FLOAT:    $req .= $this->_PackFloat($val); 
                    break;
                case SPH_ATTR_BIGINT:    $req .= sphPackI64($val); 
                    break;
                default:                $req .= pack("N", $val); 
                    break;
                }
            }
        }

        // select-list
        $req .= pack("N", strlen($this->_select)) . $this->_select;

        // mbstring workaround
        $this->_MBPop();

        // store request to requests array
        $this->_reqs[] = $req;
        return count($this->_reqs)-1;
    }

    /// connect to searchd, run queries batch, and return an array of result sets
    function RunQueries()
    {
        if (empty($this->_reqs) ) {
            $this->_error = "no queries defined, issue AddQuery() first";
            return false;
        }

        // mbstring workaround
        $this->_MBPush();

        if (!( $fp = $this->_Connect() )) {
            $this->_MBPop();
            return false;
        }

        // send query, get response
        $nreqs = count($this->_reqs);
        $req = join("", $this->_reqs);
        $len = 4+strlen($req);
        $req = pack("nnNN", SEARCHD_COMMAND_SEARCH, VER_COMMAND_SEARCH, $len, $nreqs) . $req; // add header

        if (!( $this->_Send($fp, $req, $len+8) ) 
            || !( $response = $this->_GetResponse($fp, VER_COMMAND_SEARCH) ) 
        ) {
            $this->_MBPop();
            return false;
        }

        // query sent ok; we can reset reqs now
        $this->_reqs = array ();

        // parse and return response
        return $this->_ParseSearchResponse($response, $nreqs);
    }

    /// parse and return search query (or queries) response
    function _ParseSearchResponse( $response, $nreqs )
    {
        $p = 0; // current position
        $max = strlen($response); // max position for checks, to protect against broken responses

        $results = array ();
        for ( $ires=0; $ires<$nreqs && $p<$max; $ires++ )
        {
            $results[] = array();
            $result =& $results[$ires];

            $result["error"] = "";
            $result["warning"] = "";

            // extract status
            list(,$status) = unpack("N*", substr($response, $p, 4)); $p += 4;
            $result["status"] = $status;
            if ($status!=SEARCHD_OK ) {
                list(,$len) = unpack("N*", substr($response, $p, 4)); $p += 4;
                $message = substr($response, $p, $len); $p += $len;

                if ($status==SEARCHD_WARNING ) {
                    $result["warning"] = $message;
                } else
                {
                    $result["error"] = $message;
                    continue;
                }
            }

            // read schema
            $fields = array ();
            $attrs = array ();

            list(,$nfields) = unpack("N*", substr($response, $p, 4)); $p += 4;
            while ( $nfields-->0 && $p<$max )
            {
                list(,$len) = unpack("N*", substr($response, $p, 4)); $p += 4;
                $fields[] = substr($response, $p, $len); $p += $len;
            }
            $result["fields"] = $fields;

            list(,$nattrs) = unpack("N*", substr($response, $p, 4)); $p += 4;
            while ( $nattrs-->0 && $p<$max  )
            {
                list(,$len) = unpack("N*", substr($response, $p, 4)); $p += 4;
                $attr = substr($response, $p, $len); $p += $len;
                list(,$type) = unpack("N*", substr($response, $p, 4)); $p += 4;
                $attrs[$attr] = $type;
            }
            $result["attrs"] = $attrs;

            // read match count
            list(,$count) = unpack("N*", substr($response, $p, 4)); $p += 4;
            list(,$id64) = unpack("N*", substr($response, $p, 4)); $p += 4;

            // read matches
            $idx = -1;
            while ( $count-->0 && $p<$max )
            {
                // index into result array
                $idx++;

                // parse document id and weight
                if ($id64 ) {
                    $doc = sphUnpackU64(substr($response, $p, 8)); $p += 8;
                    list(,$weight) = unpack("N*", substr($response, $p, 4)); $p += 4;
                }
                else
                {
                    list ( $doc, $weight ) = array_values(
                        unpack(
                            "N*N*",
                            substr($response, $p, 8) 
                        ) 
                    );
                    $p += 8;
                    $doc = sphFixUint($doc);
                }
                $weight = sprintf("%u", $weight);

                // create match entry
                if ($this->_arrayresult ) {
                    $result["matches"][$idx] = array ( "id"=>$doc, "weight"=>$weight );
                } else {
                    $result["matches"][$doc]["weight"] = $weight;
                }

                // parse and create attributes
                $attrvals = array ();
                foreach ( $attrs as $attr=>$type )
                {
                    // handle 64bit ints
                    if ($type==SPH_ATTR_BIGINT ) {
                        $attrvals[$attr] = sphUnpackI64(substr($response, $p, 8)); $p += 8;
                        continue;
                    }

                    // handle floats
                    if ($type==SPH_ATTR_FLOAT ) {
                        list(,$uval) = unpack("N*", substr($response, $p, 4)); $p += 4;
                        list(,$fval) = unpack("f*", pack("L", $uval)); 
                        $attrvals[$attr] = $fval;
                        continue;
                    }

                    // handle everything else as unsigned ints
                    list(,$val) = unpack("N*", substr($response, $p, 4)); $p += 4;
                    if ($type & SPH_ATTR_MULTI ) {
                        $attrvals[$attr] = array ();
                        $nvalues = $val;
                        while ( $nvalues-->0 && $p<$max )
                        {
                            list(,$val) = unpack("N*", substr($response, $p, 4)); $p += 4;
                            $attrvals[$attr][] = sphFixUint($val);
                        }
                    } else
                    {
                        $attrvals[$attr] = sphFixUint($val);
                    }
                }

                if ($this->_arrayresult ) {
                    $result["matches"][$idx]["attrs"] = $attrvals;
                } else {
                    $result["matches"][$doc]["attrs"] = $attrvals;
                }
            }

            list ( $total, $total_found, $msecs, $words ) =
            array_values(unpack("N*N*N*N*", substr($response, $p, 16)));
            $result["total"] = sprintf("%u", $total);
            $result["total_found"] = sprintf("%u", $total_found);
            $result["time"] = sprintf("%.3f", $msecs/1000);
            $p += 16;

            while ( $words-->0 && $p<$max )
            {
                list(,$len) = unpack("N*", substr($response, $p, 4)); $p += 4;
                $word = substr($response, $p, $len); $p += $len;
                list ( $docs, $hits ) = array_values(unpack("N*N*", substr($response, $p, 8))); $p += 8;
                $result["words"][$word] = array (
                "docs"=>sprintf("%u", $docs),
                "hits"=>sprintf("%u", $hits) );
            }
        }

        $this->_MBPop();
        return $results;
    }

    /////////////////////////////////////////////////////////////////////////////
    // excerpts generation
    /////////////////////////////////////////////////////////////////////////////

    /// connect to searchd server, and generate exceprts (snippets)
    /// of given documents for given query. returns false on failure,
    /// an array of snippets on success
    function BuildExcerpts( $docs, $index, $words, $opts=array() )
    {
        assert(is_array($docs));
        assert(is_string($index));
        assert(is_string($words));
        assert(is_array($opts));

        $this->_MBPush();

        if (!( $fp = $this->_Connect() )) {
            $this->_MBPop();
            return false;
        }

        /////////////////
        // fixup options
        /////////////////

        if (!isset($opts["before_match"]) ) {        $opts["before_match"] = "<b>";
        }
        if (!isset($opts["after_match"]) ) {            $opts["after_match"] = "</b>";
        }
        if (!isset($opts["chunk_separator"]) ) {        $opts["chunk_separator"] = " ... ";
        }
        if (!isset($opts["limit"]) ) {                $opts["limit"] = 256;
        }
        if (!isset($opts["around"]) ) {                $opts["around"] = 5;
        }
        if (!isset($opts["exact_phrase"]) ) {        $opts["exact_phrase"] = false;
        }
        if (!isset($opts["single_passage"]) ) {        $opts["single_passage"] = false;
        }
        if (!isset($opts["use_boundaries"]) ) {        $opts["use_boundaries"] = false;
        }
        if (!isset($opts["weight_order"]) ) {        $opts["weight_order"] = false;
        }

        /////////////////
        // build request
        /////////////////

        // v.1.0 req
        $flags = 1; // remove spaces
        if ($opts["exact_phrase"] ) {    $flags |= 2;
        }
        if ($opts["single_passage"] ) {    $flags |= 4;
        }
        if ($opts["use_boundaries"] ) {    $flags |= 8;
        }
        if ($opts["weight_order"] ) {    $flags |= 16;
        }
        $req = pack("NN", 0, $flags); // mode=0, flags=$flags
        $req .= pack("N", strlen($index)) . $index; // req index
        $req .= pack("N", strlen($words)) . $words; // req words

        // options
        $req .= pack("N", strlen($opts["before_match"])) . $opts["before_match"];
        $req .= pack("N", strlen($opts["after_match"])) . $opts["after_match"];
        $req .= pack("N", strlen($opts["chunk_separator"])) . $opts["chunk_separator"];
        $req .= pack("N", (int)$opts["limit"]);
        $req .= pack("N", (int)$opts["around"]);

        // documents
        $req .= pack("N", count($docs));
        foreach ( $docs as $doc )
        {
            assert(is_string($doc));
            $req .= pack("N", strlen($doc)) . $doc;
        }

        ////////////////////////////
        // send query, get response
        ////////////////////////////

        $len = strlen($req);
        $req = pack("nnN", SEARCHD_COMMAND_EXCERPT, VER_COMMAND_EXCERPT, $len) . $req; // add header
        if (!( $this->_Send($fp, $req, $len+8) ) 
            || !( $response = $this->_GetResponse($fp, VER_COMMAND_EXCERPT) ) 
        ) {
            $this->_MBPop();
            return false;
        }

        //////////////////
        // parse response
        //////////////////

        $pos = 0;
        $res = array ();
        $rlen = strlen($response);
        for ( $i=0; $i<count($docs); $i++ )
        {
            list(,$len) = unpack("N*", substr($response, $pos, 4));
            $pos += 4;

            if ($pos+$len > $rlen ) {
                $this->_error = "incomplete reply";
                $this->_MBPop();
                return false;
            }
            $res[] = $len ? substr($response, $pos, $len) : "";
            $pos += $len;
        }

        $this->_MBPop();
        return $res;
    }


    /////////////////////////////////////////////////////////////////////////////
    // keyword generation
    /////////////////////////////////////////////////////////////////////////////

    /// connect to searchd server, and generate keyword list for a given query
    /// returns false on failure,
    /// an array of words on success
    function BuildKeywords( $query, $index, $hits )
    {
        assert(is_string($query));
        assert(is_string($index));
        assert(is_bool($hits));

        $this->_MBPush();

        if (!( $fp = $this->_Connect() )) {
            $this->_MBPop();
            return false;
        }

        /////////////////
        // build request
        /////////////////

        // v.1.0 req
        $req  = pack("N", strlen($query)) . $query; // req query
        $req .= pack("N", strlen($index)) . $index; // req index
        $req .= pack("N", (int)$hits);

        ////////////////////////////
        // send query, get response
        ////////////////////////////

        $len = strlen($req);
        $req = pack("nnN", SEARCHD_COMMAND_KEYWORDS, VER_COMMAND_KEYWORDS, $len) . $req; // add header
        if (!( $this->_Send($fp, $req, $len+8) ) 
            || !( $response = $this->_GetResponse($fp, VER_COMMAND_KEYWORDS) ) 
        ) {
            $this->_MBPop();
            return false;
        }

        //////////////////
        // parse response
        //////////////////

        $pos = 0;
        $res = array ();
        $rlen = strlen($response);
        list(,$nwords) = unpack("N*", substr($response, $pos, 4));
        $pos += 4;
        for ( $i=0; $i<$nwords; $i++ )
        {
            list(,$len) = unpack("N*", substr($response, $pos, 4));    $pos += 4;
            $tokenized = $len ? substr($response, $pos, $len) : "";
            $pos += $len;

            list(,$len) = unpack("N*", substr($response, $pos, 4));    $pos += 4;
            $normalized = $len ? substr($response, $pos, $len) : "";
            $pos += $len;

            $res[] = array ( "tokenized"=>$tokenized, "normalized"=>$normalized );

            if ($hits ) {
                list($ndocs,$nhits) = array_values(unpack("N*N*", substr($response, $pos, 8)));
                $pos += 8;
                $res [$i]["docs"] = $ndocs;
                $res [$i]["hits"] = $nhits;
            }

            if ($pos > $rlen ) {
                $this->_error = "incomplete reply";
                $this->_MBPop();
                return false;
            }
        }

        $this->_MBPop();
        return $res;
    }

    function EscapeString( $string )
    {
        $from = array ( '\\', '(',')','|','-','!','@','~','"','&', '/', '^', '$', '=' );
        $to   = array ( '\\\\', '\(','\)','\|','\-','\!','\@','\~','\"', '\&', '\/', '\^', '\$', '\=' );

        return str_replace($from, $to, $string);
    }

    /////////////////////////////////////////////////////////////////////////////
    // attribute updates
    /////////////////////////////////////////////////////////////////////////////

    /// batch update given attributes in given rows in given indexes
    /// returns amount of updated documents (0 or more) on success, or -1 on failure
    function UpdateAttributes( $index, $attrs, $values, $mva=false )
    {
        // verify everything
        assert(is_string($index));
        assert(is_bool($mva));

        assert(is_array($attrs));
        foreach ( $attrs as $attr ) {
            assert(is_string($attr));
        }

        assert(is_array($values));
        foreach ( $values as $id=>$entry )
        {
            assert(is_numeric($id));
            assert(is_array($entry));
            assert(count($entry)==count($attrs));
            foreach ( $entry as $v )
            {
                if ($mva ) {
                    assert(is_array($v));
                    foreach ( $v as $vv ) {
                        assert(is_int($vv));
                    }
                } else {
                    assert(is_int($v));
                }
            }
        }

        // build request
        $req = pack("N", strlen($index)) . $index;

        $req .= pack("N", count($attrs));
        foreach ( $attrs as $attr )
        {
            $req .= pack("N", strlen($attr)) . $attr;
            $req .= pack("N", $mva ? 1 : 0);
        }

        $req .= pack("N", count($values));
        foreach ( $values as $id=>$entry )
        {
            $req .= sphPackU64($id);
            foreach ( $entry as $v )
            {
                $req .= pack("N", $mva ? count($v) : $v);
                if ($mva ) {
                    foreach ( $v as $vv ) {
                        $req .= pack("N", $vv);
                    }
                }
            }
        }

        // connect, send query, get response
        if (!( $fp = $this->_Connect() )) {
            return -1;
        }

        $len = strlen($req);
        $req = pack("nnN", SEARCHD_COMMAND_UPDATE, VER_COMMAND_UPDATE, $len) . $req; // add header
        if (!$this->_Send($fp, $req, $len+8) ) {
            return -1;
        }

        if (!( $response = $this->_GetResponse($fp, VER_COMMAND_UPDATE) )) {
            return -1;
        }

        // parse response
        list(,$updated) = unpack("N*", substr($response, 0, 4));
        return $updated;
    }

    /////////////////////////////////////////////////////////////////////////////
    // persistent connections
    /////////////////////////////////////////////////////////////////////////////

    function Open()
    {
        if ($this->_socket !== false ) {
            $this->_error = 'already connected';
            return false;
        }
        if (!$fp = $this->_Connect() ) {
            return false;
        }

        // command, command version = 0, body length = 4, body = 1
        $req = pack("nnNN", SEARCHD_COMMAND_PERSIST, 0, 4, 1);
        if (!$this->_Send($fp, $req, 12) ) {
            return false;
        }

        $this->_socket = $fp;
        return true;
    }

    function Close()
    {
        if ($this->_socket === false ) {
            $this->_error = 'not connected';
            return false;
        }

        fclose($this->_socket);
        $this->_socket = false;
        
        return true;
    }

    //////////////////////////////////////////////////////////////////////////
    // status
    //////////////////////////////////////////////////////////////////////////

    function Status()
    {
        $this->_MBPush();
        if (!( $fp = $this->_Connect() )) {
            $this->_MBPop();
            return false;
        }

        $req = pack("nnNN", SEARCHD_COMMAND_STATUS, VER_COMMAND_STATUS, 4, 1); // len=4, body=1
        if (!( $this->_Send($fp, $req, 12) ) 
            || !( $response = $this->_GetResponse($fp, VER_COMMAND_STATUS) ) 
        ) {
            $this->_MBPop();
            return false;
        }

        $res = substr($response, 4); // just ignore length, error handling, etc
        $p = 0;
        list ( $rows, $cols ) = array_values(unpack("N*N*", substr($response, $p, 8))); $p += 8;

        $res = array();
        for ( $i=0; $i<$rows; $i++ ) {
            for ( $j=0; $j<$cols; $j++ )
            {
                list(,$len) = unpack("N*", substr($response, $p, 4)); $p += 4;
                $res[$i][] = substr($response, $p, $len); $p += $len;
            }
        }

        $this->_MBPop();
        return $res;
    }
}

//
// $Id: sphinxapi.php 2055 2009-11-06 23:09:58Z shodan $
//
